// ============================================================================
// 定时任务使用示例
// ============================================================================

import { logger } from '@roasmax/logger'
import { TaskScheduler } from '../core/scheduler'
import { WeiboWorkflowService } from '../services/weibo-workflow-service'
import { MonitoringService } from '../services/monitoring-service'

/**
 * 定时任务使用示例
 */
export class ScheduledTaskExample {
  constructor(
    private scheduler: TaskScheduler,
    private workflowService: WeiboWorkflowService,
    private monitoringService: MonitoringService
  ) {}

  /**
   * 创建定时微博爬取任务示例
   */
  async createScheduledTaskExample(): Promise<void> {
    try {
      logger.info('开始创建定时任务示例')

      // 示例1: 创建每30分钟执行一次的社保相关微博爬取任务
      const socialSecurityTaskId = await this.workflowService.createScheduledWeiboTask(
        ['社保', '养老保险', '医疗保险'], // 关键字列表
        'example_account_id', // 账号ID（需要替换为实际的账号ID）
        {
          interval: 30 * 60 * 1000, // 30分钟
          maxPages: 3, // 每个关键字最多爬取3页
          enabled: true
        }
      )

      logger.info('社保相关定时任务创建成功', { taskId: socialSecurityTaskId })

      // 示例2: 创建每小时执行一次的科技新闻爬取任务
      const techNewsTaskId = await this.workflowService.createScheduledWeiboTask(
        ['人工智能', '区块链', '5G技术', '新能源汽车'],
        'example_account_id',
        {
          interval: 60 * 60 * 1000, // 1小时
          maxPages: 5,
          enabled: true
        }
      )

      logger.info('科技新闻定时任务创建成功', { taskId: techNewsTaskId })

      // 示例3: 创建每2小时执行一次的财经新闻爬取任务
      const financeTaskId = await this.workflowService.createScheduledWeiboTask(
        ['股市', '基金', '理财', '投资'],
        'example_account_id',
        {
          interval: 2 * 60 * 60 * 1000, // 2小时
          maxPages: 4,
          enabled: true
        }
      )

      logger.info('财经新闻定时任务创建成功', { taskId: financeTaskId })

      // 监听调度器事件
      this.setupSchedulerEventListeners()

      // 监听工作流事件
      this.setupWorkflowEventListeners()

      // 监听监控事件
      this.setupMonitoringEventListeners()

      logger.info('定时任务示例创建完成', {
        socialSecurityTaskId,
        techNewsTaskId,
        financeTaskId
      })

    } catch (error) {
      logger.error('创建定时任务示例失败', error)
      throw error
    }
  }

  /**
   * 手动执行工作流示例
   */
  async executeWorkflowExample(): Promise<void> {
    try {
      logger.info('开始执行工作流示例')

      // 手动执行一次微博爬取工作流
      const stats = await this.workflowService.executeWeiboWorkflow(
        ['热点新闻', '突发事件'], // 关键字
        'example_account_id', // 账号ID
        {
          maxPages: 2, // 每个关键字最多2页
          sendToMQ: true // 发送到消息队列
        }
      )

      logger.info('工作流执行完成', {
        totalKeywords: stats.totalKeywords,
        processedKeywords: stats.processedKeywords,
        totalWeibos: stats.totalWeibos,
        successfulWeibos: stats.successfulWeibos,
        duration: stats.duration
      })

    } catch (error) {
      logger.error('执行工作流示例失败', error)
      throw error
    }
  }

  /**
   * 监控状态查询示例
   */
  async monitoringExample(): Promise<void> {
    try {
      logger.info('开始监控状态查询示例')

      // 获取调度器状态
      const schedulerStatus = this.scheduler.getStatus()
      logger.info('调度器状态', schedulerStatus)

      // 获取工作流统计
      const workflowStats = this.workflowService.getCurrentStats()
      logger.info('工作流统计', workflowStats)

      // 获取监控指标
      const latestMetrics = this.monitoringService.getLatestMetrics()
      logger.info('最新监控指标', latestMetrics)

      // 获取活跃告警
      const activeAlerts = this.monitoringService.getActiveAlerts()
      logger.info('活跃告警', { count: activeAlerts.length, alerts: activeAlerts })

      // 获取历史指标（最近1小时）
      const historicalMetrics = this.monitoringService.getHistoricalMetrics(1)
      logger.info('历史指标', { count: historicalMetrics.length })

    } catch (error) {
      logger.error('监控状态查询示例失败', error)
      throw error
    }
  }

  /**
   * 设置调度器事件监听器
   */
  private setupSchedulerEventListeners(): void {
    this.scheduler.on('scheduler:started', () => {
      logger.info('调度器已启动')
    })

    this.scheduler.on('scheduler:stopped', () => {
      logger.info('调度器已停止')
    })

    this.scheduler.on('task:scheduled', (task) => {
      logger.info('任务已调度', { taskId: task.id, type: task.type })
    })

    this.scheduler.on('task:completed', (task) => {
      logger.info('定时任务执行完成', { taskId: task.id })
    })

    this.scheduler.on('task:failed', (task, error) => {
      logger.error('定时任务执行失败', { taskId: task.id, error })
    })

    this.scheduler.on('scheduler:health-check', (status) => {
      logger.debug('调度器健康检查', status)
    })
  }

  /**
   * 设置工作流事件监听器
   */
  private setupWorkflowEventListeners(): void {
    // 工作流服务目前没有事件发射器，这里是示例代码
    logger.info('工作流事件监听器已设置')
  }

  /**
   * 设置监控事件监听器
   */
  private setupMonitoringEventListeners(): void {
    this.monitoringService.on('monitoring:started', () => {
      logger.info('监控服务已启动')
    })

    this.monitoringService.on('monitoring:stopped', () => {
      logger.info('监控服务已停止')
    })

    this.monitoringService.on('metrics:collected', (metrics) => {
      logger.debug('监控指标已收集', {
        timestamp: metrics.timestamp,
        memoryUsageMB: Math.round(metrics.system.memoryUsage.heapUsed / 1024 / 1024),
        activeJobs: metrics.scheduler.activeJobs
      })
    })

    this.monitoringService.on('alert:created', (alert) => {
      logger.warn('新告警创建', alert)
    })

    this.monitoringService.on('alert:resolved', (alert) => {
      logger.info('告警已解决', { alertId: alert.id, type: alert.type })
    })
  }

  /**
   * 任务管理示例
   */
  async taskManagementExample(): Promise<void> {
    try {
      logger.info('开始任务管理示例')

      // 获取调度器状态
      const status = this.scheduler.getStatus()
      logger.info('当前调度器状态', status)

      // 如果有任务，演示立即执行
      if (status.totalJobs > 0) {
        logger.info('发现定时任务，演示立即执行功能')
        // 注意：这里需要实际的任务ID
        // await this.scheduler.executeTaskNow('actual_task_id')
      }

      // 演示更新监控配置
      this.monitoringService.updateConfig({
        interval: 30 * 1000, // 改为30秒
        alertThresholds: {
          memoryUsage: 256, // 降低内存告警阈值
          errorRate: 5,
          queueBacklog: 500
        }
      })

      logger.info('监控配置已更新')

    } catch (error) {
      logger.error('任务管理示例失败', error)
      throw error
    }
  }

  /**
   * 运行完整示例
   */
  async runFullExample(): Promise<void> {
    try {
      logger.info('开始运行完整的定时任务示例')

      // 1. 创建定时任务
      await this.createScheduledTaskExample()

      // 等待一段时间让任务调度
      await new Promise(resolve => setTimeout(resolve, 5000))

      // 2. 查询监控状态
      await this.monitoringExample()

      // 3. 手动执行工作流
      // await this.executeWorkflowExample() // 需要有效的账号ID才能执行

      // 4. 任务管理操作
      await this.taskManagementExample()

      logger.info('完整示例运行完成')

    } catch (error) {
      logger.error('运行完整示例失败', error)
      throw error
    }
  }
}

/**
 * 导出示例运行函数
 */
export async function runScheduledTaskExample(
  scheduler: TaskScheduler,
  workflowService: WeiboWorkflowService,
  monitoringService: MonitoringService
): Promise<void> {
  const example = new ScheduledTaskExample(scheduler, workflowService, monitoringService)
  await example.runFullExample()
}
